home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 May / EnigmA AMIGA RUN 07 (1996)(G.R. Edizioni)(IT)[!][issue 1996-05][EARSAN CD VI].iso / rubriche / programm / wbclone.c
C/C++ Source or Header  |  1996-04-23  |  11KB  |  364 lines
  1. /*****************************************************************************
  2. * Listato 1                                                                  *
  3. * Questo listato (preso e modificato dal RKM), mostra come creare una View,  *
  4. * completa di ViewPort, ColorMap, BitMap e RastPort per disegnare, copiando  *
  5. * quelle del Workbench                                                       *
  6. *****************************************************************************/
  7.  
  8. #include <exec/types.h>
  9. #include <exec/exec.h>
  10. #include <clib/exec_protos.h>
  11. #include <intuition/screens.h>
  12. #include <intuition/intuition.h>
  13. #include <intuition/intuitionbase.h>
  14. #include <clib/intuition_protos.h>
  15. #include <graphics/gfx.h>
  16. #include <graphics/gfxbase.h>
  17. #include <graphics/view.h>
  18. #include <graphics/gfxnodes.h>
  19. #include <graphics/videocontrol.h>
  20. #include <clib/graphics_protos.h>
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23.  
  24. /* strutture di utilizzo globale */
  25. struct IntuitionBase *IntuitionBase = NULL;
  26. struct GfxBase *GfxBase = NULL;
  27.  
  28. /* definizione dei prototipi di funzione */
  29. void Init(void);
  30. void CloseAll(void);
  31. void LiberaView(struct View *view);
  32.  
  33. /* apre le librerie Intuition.library e Graphics.library */
  34. void Init()
  35. {
  36.   if ((IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37L)) == NULL)
  37.   {
  38.     printf("Non posso aprire la libreria Intuition V37\n");
  39.     exit(1);
  40.   }
  41.  
  42.   if ((GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",36L)) == NULL)
  43.   {
  44.     printf("Non posso aprire la libreria Graphics V36\n");
  45.     CloseLibrary((struct Library *)IntuitionBase);
  46.     exit(1);
  47.   }
  48.  
  49.   return;
  50. }
  51.  
  52. /* Chiude le librerie */
  53. void CloseAll()
  54. {
  55.   if (GfxBase != NULL) CloseLibrary((struct Library *)GfxBase);
  56.   if (IntuitionBase != NULL) CloseLibrary((struct Library *)IntuitionBase);
  57.  
  58.   return;
  59. }
  60.  
  61. /* Libera la View view precedentemente allocata */
  62. void LiberaView(struct View *view)
  63. {
  64.   struct ViewExtra *ve;
  65.  
  66.   if (view)
  67.   {
  68.     /* preleva, se esiste, la ViewPortExtra della View */
  69.     if (ve = (struct ViewExtra *)GfxLookUp(view))
  70.     {
  71.       /* Chiude il monitor della ViewExtra */
  72.       if (ve -> Monitor) CloseMonitor(ve -> Monitor);
  73.       /* Libera la ViewExtra */
  74.       GfxFree((struct ExtendedNode *)ve);
  75.     }
  76.     /* Libera la memoria occupata dalle Copper List create al MakeVPort */
  77.     if (view -> LOFCprList) FreeCprList(view -> LOFCprList);
  78.     if (view -> SHFCprList) FreeCprList(view -> SHFCprList);
  79.     /* Libera la memoria occupata dalla struttura View */
  80.     FreeMem(view,sizeof(struct View));
  81.   }
  82.   return;
  83. }
  84.  
  85. /* Crea una struttura View adeguatamente inizializzata, con i parametri
  86.    della view passata e con la modalita' video ModeID */
  87. struct View *DupView(struct View *v, ULONG ModeID)
  88. {
  89.   struct View *view = NULL;
  90.   struct ViewExtra *ve = NULL;
  91.   struct MonitorSpec *monsp = NULL;
  92.  
  93.   /* Alloca la memoria per la struttura View */
  94.   if (view = AllocMem(sizeof(struct View), MEMF_PUBLIC|MEMF_CLEAR))
  95.   {
  96.     /* Alloca la ViewExtra */
  97.     if (ve = GfxNew(VIEW_EXTRA_TYPE))
  98.     {
  99.       /* Apre il monitor di codice ModeID */
  100.       if (monsp = OpenMonitor(NULL, ModeID))
  101.       {
  102.         /* Inizializza la View */
  103.         InitView(view);
  104.         /* Copia i parametri della View passata in quella creata */
  105.         view -> DyOffset = v -> DyOffset;
  106.         view -> DxOffset = v -> DxOffset;
  107.         view -> Modes = v -> Modes;
  108.         /* Associa la ViewExtra alla View */
  109.         GfxAssociate(view, (struct ExtendedNode *)ve);
  110.         /* Specifica il monitor aperto nella ViewExtra */
  111.         ve -> Monitor = monsp;
  112.       }
  113.       else printf("Non posso aprire il monitor\n");
  114.     }
  115.     else printf("Non posso allocare il View Extra\n");
  116.   }
  117.   else printf("Non posso creare la View\n");
  118.  
  119.   if (view && ve && monsp) return(view);
  120.   else
  121.   {
  122.     LiberaView(view);
  123.     return(NULL);
  124.   }
  125. }
  126.  
  127. /* Libera la ViewPort precedentemente allocata */
  128. void LiberaViewPort(struct ViewPort *vp)
  129. {
  130.   struct ColorMap *cm;
  131.   struct TagItem ti[] =
  132.   {
  133.     { VTAG_VIEWPORTEXTRA_GET, NULL },
  134.     { VTAG_END_CM, NULL }
  135.   };
  136.  
  137.   if (vp)
  138.   {
  139.     cm = vp -> ColorMap;
  140.     if (cm)
  141.     {
  142.       /* Preleva la ViewPortExtra eventualmente collegata a questa ViewPort */
  143.       if (VideoControl(cm,ti) == NULL)
  144.         /* Libera la ViewPortExtra */
  145.         GfxFree((struct ExtendedNode *)ti[0].ti_Data);
  146.       else
  147.         printf("Errore nella funzione VideoControl, non posso liberare la ViewPortExtra\n");
  148.       /* Libera la ColorMap */
  149.       FreeColorMap(cm);
  150.     }
  151.     else printf("Errore, non posso liberare la ColorMap\n");
  152.     /* Libera la Copper List dedicata a questa ViewPort */
  153.     FreeVPortCopLists(vp);
  154.     /* Libera la memoria allocata dalla struttura ViewPort */
  155.     FreeMem(vp,sizeof(struct ViewPort));
  156.   }
  157.  
  158.   return;
  159. }
  160.  
  161. /* Crea una struttura ViewPort inizializzandola con i parametri della ViewPort
  162.    passata e con la modalita' indicata */
  163. struct ViewPort *DupViewPort(struct ViewPort *vp, ULONG ModeID)
  164. {
  165.   struct ViewPort *viewport;
  166.   struct ViewPortExtra *vpe;
  167.   struct ColorMap *cm;
  168.   struct TagItem ti[] =
  169.   {
  170.     { VTAG_ATTACH_CM_SET,NULL },
  171.     { VTAG_VIEWPORTEXTRA_SET,NULL },
  172.     { VTAG_NORMAL_DISP_SET,NULL },
  173.     { VTAG_END_CM,NULL },
  174.   };
  175.   struct DimensionInfo query = {0};
  176.   ULONG colour[3];
  177.   int c;
  178.   ULONG gotinfo = NULL;
  179.  
  180.   /* Alloca la memoria per la struttura ViewPort */
  181.   if (viewport = AllocMem(sizeof(struct ViewPort), MEMF_CLEAR|MEMF_PUBLIC))
  182.   {
  183.     /* Alloca la ViewPortExtra */
  184.     if (vpe = (struct ViewPortExtra *)GfxNew(VIEWPORT_EXTRA_TYPE))
  185.     {
  186.       /* Alloca la ColorMap per 256 colori (il massimo utilizzabile) */
  187.       if (cm = GetColorMap(256))
  188.       {
  189.         /* Preleva le informazioni sul display di ModeID e lo inserisce in query */
  190.         if (gotinfo = GetDisplayInfoData(NULL, (APTR)&query, sizeof(query), DTAG_DIMS, ModeID))
  191.         {
  192.           /* Inizializza la ViewPort */
  193.           InitVPort(viewport);
  194.           /* Copia i parametri della ViewPort passata in quella creata */
  195.           viewport -> DWidth = vp -> DWidth;
  196.           viewport -> DHeight = vp -> DHeight;
  197.           viewport -> DxOffset = vp -> DxOffset;
  198.           viewport -> DyOffset = vp -> DyOffset;
  199.           viewport -> Modes = vp -> Modes;
  200.           viewport -> SpritePriorities = vp -> SpritePriorities;
  201.           viewport -> ExtendedModes = vp -> ExtendedModes;
  202.           /* Imposta il DisplayClip */
  203.           vpe -> DisplayClip = query.TxtOScan;
  204.           /* Imposta i ti_Data dei tag da utilizzare per la chiamata
  205.              VideoControl che unisce tutto */
  206.           ti[0].ti_Data = (ULONG)viewport;
  207.           ti[1].ti_Data = (ULONG)vpe;
  208.           ti[2].ti_Data = (ULONG)FindDisplayInfo(ModeID);
  209.           /* Associa ViewPort, ViewPortExtra e ModeID */
  210.           if (VideoControl(cm,ti) != NULL)
  211.             printf("Errore in VideoControl per la creazione della ViewPort\n");
  212.           /* Copia i colori dalla ColorMap della ViewPort passata a quella creata */
  213.           for (c=0; c<256; c++)
  214.           {
  215.             GetRGB32(vp -> ColorMap, c, 1, colour);
  216.             SetRGB32CM(cm, c, colour[0], colour[1], colour[2]);
  217.           }
  218.         }
  219.         else printf("Non posso ottenere il DisplayInfo\n");
  220.       }
  221.       else printf("Non posso allocare la ColorMap\n");
  222.     }
  223.     else printf("Non posso allocare la ViewPortExtra\n");
  224.   }
  225.   else printf("Non posso allocare la ViewPort\n");
  226.  
  227.   if (viewport && vpe && cm && gotinfo) return(viewport);
  228.   else
  229.   {
  230.     LiberaViewPort(viewport);
  231.     return(NULL);
  232.   }
  233. }
  234.  
  235. /* Libera la BitMap precedentemente allocata */
  236. void LiberaBitMap(struct BitMap *bm, SHORT width, SHORT height, SHORT depth)
  237. {
  238.   int i;
  239.  
  240.   if (bm)
  241.   {
  242.     /* Libera ogni bitplane */
  243.     for (i=0; i<depth; i++)
  244.       if (bm -> Planes[i]) FreeRaster(bm -> Planes[i], width, height);
  245.     /* Libera la memoria allocata per la struttura BitMap */
  246.     FreeMem(bm,sizeof(struct BitMap));
  247.   }
  248.  
  249.   return;
  250. }
  251.  
  252. /* Crea una bitmap di dimensioni date */
  253. struct BitMap *CreateBitMap(SHORT width, SHORT height, SHORT depth)
  254. {
  255.   struct BitMap *bm;
  256.   PLANEPTR allocated = (PLANEPTR)1;
  257.   int i;
  258.  
  259.   /* Alloca la memoria per la struttura BitMap */
  260.   if (bm = AllocMem(sizeof(struct BitMap), MEMF_CLEAR|MEMF_PUBLIC))
  261.   {
  262.     /* Inizializza la BitMap */
  263.     InitBitMap(bm, depth, width, height);
  264.     /* Alloca i bitplanes */
  265.     for (i=0; i<depth; i++)
  266.       allocated = (bm -> Planes[i] = AllocRaster(width, height));
  267.     if (allocated == NULL)
  268.     {
  269.       printf("Non posso allocare i bitplanes\n");
  270.       LiberaBitMap(bm,width,height,depth);
  271.       bm = NULL;
  272.     }
  273.   }
  274.   else printf("Non posso allocare la struttura BitMap\n");
  275.  
  276.   return(bm);
  277. }
  278.  
  279. /* Mostra la View creata */
  280. void ShowView(struct View *view, struct ViewPort *vp, struct BitMap *bm, SHORT width, SHORT height)
  281. {
  282.   struct RastPort *rp;
  283.   struct RasInfo *ri;
  284.   int i;
  285.  
  286.   /* Alloca la memoria utilizzata per la struttura RastPort */
  287.   if (rp = AllocMem(sizeof(struct RastPort), MEMF_CLEAR|MEMF_PUBLIC))
  288.   {
  289.     /* Alloca la memoria utilizzata per la struttura RasInfo */
  290.     if (ri = AllocMem(sizeof(struct RasInfo), MEMF_CLEAR|MEMF_PUBLIC))
  291.     {
  292.       /* Inizializza la RastPort */
  293.       InitRastPort(rp);
  294.       /* Associamo la BitMap alla RastPort ed alla RasInfo */
  295.       ri -> BitMap = rp -> BitMap = bm;
  296.       /* Associamo la RasInfo alla ViewPort */
  297.       vp -> RasInfo = ri;
  298.       /* Imposta la ViewPort nella View */
  299.       view -> ViewPort = vp;
  300.       /* Disegna un rettangolo */
  301.       SetRast(rp,0);
  302.       for (i=0; i<((1 << bm->Depth)-1); i++)
  303.       {
  304.         SetAPen(rp,i);
  305.         Move(rp,i,i);
  306.         Draw(rp,width-i,i);
  307.         Draw(rp,width-i,height-i);
  308.         Draw(rp,i,height-i);
  309.         Draw(rp,i,i);
  310.       }
  311.       /* Crea la View con tutte le CopperList e la mostra */
  312.       MakeVPort(view, vp);
  313.       MrgCop(view);
  314.       LoadView(view);
  315.       /* attende un tasto per procedere */
  316.       getchar();
  317.       /* ridisegna il vecchio display */
  318.       RethinkDisplay();
  319.       /* Libera la memoria allocata dalla struttura RasInfo */
  320.       FreeMem(ri,sizeof(struct RasInfo));
  321.     }
  322.     else printf("Non posso allocare la RasInfo\n");
  323.  
  324.     /* Libera la memoria allocata dalla struttura RastPort */
  325.     FreeMem(rp, sizeof(struct RastPort));
  326.   }
  327.   else printf("Non posso allocare la RastPort\n");
  328.  
  329.   return;
  330. }
  331.  
  332. void main(int argc, char *argv[])
  333. {
  334.   struct Screen *wb;
  335.   struct View *NuovaView;
  336.   struct ViewPort *NuovaVP;
  337.   struct BitMap *NuovaBitMap;
  338.   ULONG ModeID,IbaseLock;
  339.  
  340.   Init();
  341.   if (wb = LockPubScreen("Workbench"))
  342.   {
  343.     ModeID = GetVPModeID(&wb->ViewPort);
  344.     IbaseLock = LockIBase(0);
  345.     if (NuovaView = DupView(&IntuitionBase->ViewLord, ModeID))
  346.     {
  347.       UnlockIBase(IbaseLock);
  348.       if (NuovaVP = DupViewPort(&wb->ViewPort, ModeID))
  349.       {
  350.         if (NuovaBitMap = CreateBitMap(wb->Width,wb->Height,wb->BitMap.Depth))
  351.         {
  352.           ShowView(NuovaView, NuovaVP, NuovaBitMap, wb->Width-1, wb->Height-1);
  353.           LiberaBitMap(NuovaBitMap,wb->Width,wb->Height,wb->BitMap.Depth);
  354.         }
  355.         LiberaViewPort(NuovaVP);
  356.       }
  357.       LiberaView(NuovaView);
  358.     }
  359.     else UnlockIBase(IbaseLock);
  360.     UnlockPubScreen(NULL, wb);
  361.   }
  362.   CloseAll();
  363. }
  364.